Computers have become an integral part of society—every day people become more dependent on this technology to facilitate both work and also leisure activities. A significant drawback to such technology is its “digital” nature as compared to the “analog” world in which it functions. Computing technology operates in a digital domain that requires discrete states to be identified in order for information to be processed. In simple terms, information must be input into a computing system with a series of “on” and “off” states. However, humans live in a distinctly analog world where occurrences are never completely black or white, but always seem to be in between or shades of gray. Thus, a main difference between digital and analog is that digital requires discrete states that are disjunct over time (e.g., distinct levels) while analog is continuous over time. Since humans naturally operate in an analog fashion, computing technology has evolved to reduce the impact it has when interfacing with “nondigital entities” or humans.
A set of structured keys is one of the earliest human-machine interface devices, traditionally utilized in a typewriter. This interface system was adapted to interact, not with mechanical keys and paper, but to trigger discrete states that would be transmitted to a computing system. Thus, a computer “keyboard” was developed, allowing humans to utilize an existing, familiar interface with unfamiliar technology. This eased the transition into the computer age. Unfortunately, not everyone who wanted to utilize a computer knew how to type. This limited the number of computer users who could adequately utilize the computing technology. One solution was to introduce a graphical user interface that allowed a user to select pictures from a computing monitor to make the computer do a task. Thus, control of the computing system was typically achieved with a pointing and selecting device known as a “mouse.” This permitted a greater number of people to utilize computing technology without having to learn to use a keyboard. Although, these types of devices made employing computing technology easier, it still did not address mankind's age old method of communicating—handwriting.
Technology first focused on attempting to input existing typewritten or typeset information into computers. Scanners or optical imagers were used, at first, to “digitize” pictures (e.g., input images into a computing system). Once images could be digitized into a computing system, it followed that printed or typeset material should be able to be digitized also. However, an image of a scanned text page cannot be manipulated as text after it is brought into a computing system. The characters and words are “pictures” and not actually editable text. Thus, optical character recognition (OCR) technology was developed to utilize scanning technology to digitize text as an editable page. This technology worked reasonably well if a particular text font was utilized that allowed the OCR software to translate a scanned image into editable text. At first, this technology had an accuracy of about 50 to 60%, but today it has progressed to an accuracy of near 98 to 99% or higher. OCR technology has even evolved to the point where it can take into account not only recognizing a text character, but also retaining paragraph and page formatting and even font characteristics.
Subsequently, OCR technology reached an accuracy level where it seemed practical to attempt to utilize it to recognize handwriting. After all, why transpose handwriting to text via a keyboard if it can be directly digitized into a computing system? The problem with this approach is that existing OCR technology was tuned to recognize limited or finite choices of possible types of fonts. Thus, it could “recognize” a character by comparing it to a database of pre-existing fonts. If a font was a incoherent, the OCR technology would return strange or “non-existing” characters, indicating that it did not recognize the text. Handwriting proved to be an even more extreme case of this problem. When a person writes, their own particular style shows through in their penmanship. Signatures are used, due to this uniqueness, in legal documents because they distinguish a person from everyone else. Thus, by its very nature, handwriting has infinite forms even for the same character. Obviously, storing every conceivable form of handwriting for a particular character would prove impossible. Other means needed to be achieved to make handwriting recognition a reality.
One of the earlier attempts at handwriting recognition involved “handwriting” that was actually not handwriting at all. A system of “strokes” or lines was utilized as input into a computing system via a “tablet” or writing surface that could be digitized and translated into the system. Although, attempts were made to make the strokes very symbolic of a printed text letter, the computing system was not actually recognizing handwriting. In fact, this method actually forces humans to adapt to a machine or system being used. Further developments were made to actually recognize true handwriting. Again, if a system was required to match every conceivable variation of a letter to one in a given database, it would take enormous processing resources and time. Therefore, some of the first advances were made in areas that had at least a finite, even though rather large, group of possibilities. The resulting technology proved invaluable for operations such as sorting mail. In this case, an attempt can be made to optically recognize for instance, a city name. Should a computing system fail to “comprehend” the name, it can utilize “context” such as what state a piece of mail is from and if the system recognize at least some of the characters in the city name. This allows a search to proceed in a database of a state's city names, often resolving the discrepancy and resulting in a higher yield of “readable” addresses.
Of course, the introduction in the United States of postal zip codes minimizes the OCR technology's importance for reading name addresses. Thus, the technology can concentrate mainly on recognizing only numbers and not letters. This limits the necessary translation to only 10 characters (0 through 9). However, depending upon location, schooling, and other factors, people learn to write numbers differently. The most common varying numbers are “2's” and “4's.” People often write 2's with or without a loop and write 4's either closed or open on top. These variations of the same character are taken into account by the handwriting technology, so that different variations of the same character are interpreted by the computing system as the same character. This works fairly efficiently due to the limited number of characters and, therefore, the limited number of allowed variations.
One can appreciate that recognizing numbers is a step in the right direction. But, most computing system users would like to have the system directly recognize all of the characters in the alphabet as well as special characters such as ‘#’, ‘$’, etc.; and not just numbers. People prefer to force machines to learn from them rather than adapting to how the machine works. Thus, “learning” computing systems have evolved to facilitate in this area of human-machine interfaces. Handwriting recognition has been taken to more advanced levels by technology that allows a computing system to absorb a unique user's writing style. In this context, methods are employed to accurately interpret and exploit what a user inputs over a period of time. In order to speed up the learning process, often a technology will require structured user input or “enrollment” information to increase the technology's performance. A typical enrollment might require a user to write numbers, characters, special characters, and certain paragraphs to tune the computing system for recognition. Currently, this can be a quite lengthy process, and it is not uncommon for the process to take a substantial amount of time before high accuracy can be achieved.
Although training handwriting recognition technology can seem laborious, the benefits of having this capability over traditional computing system interfaces are tremendous. Currently, the most efficient means for multiple users to input information into a system is via the keyboard. This is due to the fact that the keyboard is typically universal in design, and therefore, always a standardized interface, easily employable by many different users. However, ergonomics (e.g., human comfort with using a device) for a keyboard require that the keys be spaced a particular distance. This drives a certain minimum size for the entire keyboard, making it inconvenient for portable use. While handheld computing devices and the like are small and pocket friendly, data entry for these types of devices utilizing cryptic stroke recognition and/or tapping techniques tends to make these devices tedious to use. Once again, users are forced to learn a machine rather than the machine learning the user. Some manufacturers have attempted to produce smaller more compact keyboards to overcome this deficiency, but these “advances” have proved inconvenient for users because the resulting devices are either cumbersome and/or non-ergonomic. Portable and non-portable computing devices prove most valuable when users are able to directly input information via ordinary handwriting. This allows these devices to be utilized by skilled and unskilled users alike.